2011-08-09  Jonathan Pryor  <jonpryor@vt.edu>

	[System,MOBILE] Add
	System.Text.RegularExpressions.RegexOptions.Compiled.

	Add the RegexOptions.Compiled enumeration value to the MOBILE
	profile.

	Fixes: http://bugzilla.xamarin.com/show_bug.cgi?id=149

	MonoTouch and Mono for Android still use `PatternCompiler`, which
	is interpreted. Thus RegexOptions.Compiled is ignored, and is
	present only for compatibility with Windows Phone 7, which states
	[0]:

	Present only in Silverlight for Windows Phone, but not supported.

	[0]
	http://msdn.microsoft.com/en-us/library/system.text.regularexpressions.regexoptions(VS.96).aspx

2011-01-06  Zoltan Varga  <vargaz@gmail.com>

	Change some usages of ArrayList to List<T> to avoid calls to the
	slow ArrayList.ToArray(Type) method.

2010-10-15  Marek Safar  <marek.safar@gmail.com>

	Clean up few more warnings

2010-07-20  Miguel de Icaza  <miguel@novell.com>

	* parser.cs (ParseEscape): Now parses with some context, whether
	we are parsing inside a character range which can not contain
	back-references or when we are parsing on a string context which
	can contain back references.

	This fixes bug #577346 which exposed a bug parsing this:

	new Regex("[\\177-\\377]")

2010-06-29  Raja R Harinath  <harinath@hurrynot.org>

	Mitigate a possible source of unbounded memory growth
	* interpreter.cs (Backtrack): Move mark_start back, and invalidate
	discarded marks.

2010-06-29  Raja R Harinath  <harinath@hurrynot.org>

	Make trace output resemble assembler listing
	* compiler.cs (LinkRef.ToString) [TRACE_REGEX]: Add pretty-printer
	in TRACE_REGEX mode.
	(TraceRegexp): Indent the output.
	(TraceRegexpLabel): New.  Prints out a line label.
	(EmitCount): Don't trace.  All callers are traced.
	(ResolveLink): Trace line labels.

2010-06-21  Rodrigo Kumpera  <rkumpera@novell.com>

	* compiler.cs: Use conditional compilation to enable
	tracing to avoid code bloat.

2010-06-21  Rodrigo Kumpera  <rkumpera@novell.com>

	* parser.cs: Handle repetition of position assertions.

	Fixes #610587.

2010-06-21  Rodrigo Kumpera  <rkumpera@novell.com>

	* compiler.cs: Add new internal flag to switch on regexp tracing.
	The code is a statc readonly variable so the JIT can eliminate
	all tracing code during normal runs.

2010-03-20  Miguel de Icaza  <miguel@novell.com>

	* RxInterpreter.cs: Removed warnings.

2010-02-03  Rodrigo Kumpera  <rkumpera@novell.com>

	* BaseMachine.cs (Split): Don't add empty strings if they don't come from
	the first capture group. Fixes #566117.

2010-01-12  Miguel de Icaza  <miguel@novell.com>

	* Regex.cs: Re-enable the new regex compiler as the bug seems to
	be gone now.

2009-09-07  Raja R Harinath  <harinath@hurrynot.org>

	* Regex.cs (Escape, Unescape): Add null checks.
	(validate_options): Add ECMAScript option checks.
	(Replace, Split): Add a few bounds checks.

2009-09-07  Raja R Harinath  <harinath@hurrynot.org>

	Add some null checks and bounds checks.
	* Regex.cs (default_startat): New.  Replaces the fragment
	'RightToLeft ?  input.Length : 0' with a null-safe variant.
	(Replace) <string variant>: Add null checks for argument strings.
	(Split): Likewise.
	(.ctor): Likewise.  Validate regex options partially.
	(Match): Add null check on string arguments, and bounds checks for
	offset and length arguments.

2009-08-20  Raja R Harinath  <harinath@hurrynot.org>

	Final piece of explicit numeric group support
	* parser.cs (gap): New.
	(GetMapping): Return it.
	(ResolveReferences): Collect explicit numeric groups which may not
	match their indices.
	(HandleExplicitNumericGroups): New.  Process the above list to
	assign appropriate indices, and compute the correct value of 'gap'.

2009-08-20  Raja R Harinath  <harinath@hurrynot.org>

	* syntax.cs (CapturingGroup.Index): Rename from Number to clarify
	semantics.
	(CapturingGroup.CompareTo): New.
	* parser.cs, syntax.cs: Update to changes.

2009-08-20  Raja R Harinath  <harinath@hurrynot.org>

	Implement some more group number/index distinction
	* Regex.cs (gap, Gap): New.
	(Init, InitNewRegex): Update it.
	(GroupNumberFromName): If the 'name' is beyond the gap, it is an
	explicit numeric group -- use the name as the group number.
	(GetGroupIndex): Use a binary search to map a group number to its
	index when we know that they don't match.
	(GroupNumbers): Use group number, not group index, for explicit
	numeric groups.
	* Match.cs (.ctor): Use the newly introduce 'Regex.Gap'.

2009-08-19  Raja R Harinath  <harinath@hurrynot.org>

	* Regex.cs (group_numbers): New.
	(GetGroupNumbers): Move array initialization ...
	(GroupNumbers): ... to new on-demand initializer.

2009-08-19  Raja R Harinath  <harinath@hurrynot.org>

	* Regex.cs (group_names): Rename from _groupNumbersToNameMap.
	(GetGroupNamesArray): Use an IDictionaryEnumerator to walk the
	mapping, since both the key and value are used in the loop.

2009-08-19  Raja R Harinath  <harinath@hurrynot.org>

	Introduce 'gap' concept into all the variants of regex
	* arch.cs (IMachineFactory::Gap): New property.
	* compiler.cs (InterpreterFactory): Update to changes.
	* RxCompiler.cs (RxInterpreterFactory): Likewise.
	* JvmReMachineFactory.cs: Likewise.
	* parser.cs (GetMapping): Return the 'gap' index.  Move creation
	of mapping dictionary ...
	* Regex.cs (CreateMachineFactory): ... here.  Update to changes.

2009-08-18  Raja R Harinath  <harinath@hurrynot.org>

	Distinguish between the internal index of a group and group number.
	* Regex.cs (GetGroupIndex): New.
	(GroupNameFromNumber): Use it.
	* GroupCollection.cs (.ctor): Introduce 'gap' argument.  It is the
	index of the first group whose group number differs from its index.
	(Item.get): Likewise.

2009-08-18  Raja R Harinath  <harinath@hurrynot.org>

	* parser.cs (GetMapping): Extend duplicate check for numeric
	groups too.

2009-08-17  Raja R Harinath  <harinath@hurrynot.org>

	* parser.cs (ResolveReferences): Handle some cases of
	explicitly-named numeric groups.

2009-08-17  Raja R Harinath  <harinath@hurrynot.org>

	* parser.cs (ResolveReferences): Rearrange slightly to prepare for
	future changes.

2009-08-17  Raja R Harinath  <harinath@hurrynot.org>

	* Regex.cs (GetGroupNumbers): List group numbers in ascending order.
	(GetGroupNames): List names in order of group number.

2009-08-12  Raja R Harinath  <harinath@hurrynot.org>

	* syntax.cs (BackslashNumber.ResolveReference): Improve ECMAScript
	semantics.  Handle cases like "group 43 exists but group 4 doesn't".

2009-08-10  Raja R Harinath  <harinath@hurrynot.org>

	* syntax.cs (BackslashNumber.ResolveReference): Implement fallback
	to octal numbers, and ECMAScript semantics.
	* parser.cs (ResolveReferences): Use it.

2009-08-10  Raja R Harinath  <harinath@hurrynot.org>

	* syntax.cs (BackslashNumber): New class.
	* parser.cs (ParseSpecial): Create it instead of 'Reference' if a
	numeric backreference is seen.

2009-08-10  Raja R Harinath  <harinath@hurrynot.org>

	* parser.cs (ResolveReferences): Allow named groups to be
	referred-to by their group numbers too.

2009-04-23  Sebastien Pouliot  <sebastien@ximian.com>

	* Regex.cs: Remove Compiler-related support for NET_2_1
	* RegexOptions.cs: Remove Compile from values available on NET_2_1

2009-03-04  Zoltan Varga  <vargaz@gmail.com>

	* RxInterpreter.cs (ResetGroups): Avoid allocating larger than needed
	arrays.

2009-02-27  Jonathan Pryor <jpryor@novell.com>

	* Regex.cs (Replace): Check that input & evaluator are not null, as
	  documented in MSDN (and the variance found while testing DbLinq).

2009-02-27  Zoltan Varga  <vargaz@gmail.com>

	* BaseMachine.cs (LTRReplace): Initialize the StringBuilder with an
	appropriate initial length.

2009-02-24  Zoltan Varga  <vargaz@gmail.com>

	* CILCompiler.cs: Partially inline calls to Char.ToLower () to speed
	up ignorecase matching.

2009-02-16  Jb Evain  <jbevain@novell.com>

	* Regex.cs: on the NET_2_1 profile, always use the old engine for now.

2009-02-14  Zoltan Varga  <vargaz@gmail.com>

	* Regex.cs: Add a MONO_NEW_RX variable to enable the new regex
	engine.

2009-02-04  Zoltan Varga  <vargaz@gmail.com>

	* Regex.cs: Disable the new regex engine for now.

2009-01-14  Zoltan Varga  <vargaz@gmail.com>

	* CILCompiler.cs: Avoid throwing exceptions for a few more unhandled opcodes.
	Implement the reverse/ignorecase versions of Reference. Fix the reverse
	version of Bitmap. Error out if a Jump opcode jumps outside the current
	pc range. This works around #466151.

2009-01-12  Jb Evain  <jbevain@novell.com>

	* RxInterpreter.cs: set trace_rx to false for NET_2_1.
	* Regex.cs: set old_rx to false for NET_2_1.

2009-01-07  Zoltan Varga  <vargaz@gmail.com>

	* RxInterpreter.cs: Add support for constant strings in anchors. Fixes
	#464135.

2008-11-18 Gonzalo Paniagua Javier <gonzalo@novell.com>

	* cache.cs: avoid infinite loop.

2008-11-14 Gonzalo Paniagua Javier <gonzalo@novell.com>

	* cache.cs:
	* Regex.cs: honor CacheSize value.

2008-11-13  Zoltan Varga  <vargaz@gmail.com>

	* RxInterpreter.cs: Fix pc computation in various opcodes. Fixes #443841.

2008-11-11  Zoltan Varga  <vargaz@gmail.com>

	* CILCompiler.cs: Implement Reference opcode.

2008-10-30  Zoltan Varga  <vargaz@gmail.com>

	* CILCompiler.cs: Implement SubExpression opcode.
	
	* CILCompiler.cs: Save and restore strpos in the Test opcode. Fixes
	#439947.

2008-10-25  Zoltan Varga  <vargaz@gmail.com>

	* CILCompiler.cs: Implement Test opcode.

2008-10-25 Gonzalo Paniagua Javier <gonzalo@novell.com>

	* RxInterpreter.cs: implement missing Unicode* opcodes and
	StringReverseIgnoreCase.

2008-10-25  Zoltan Varga  <vargaz@gmail.com>

	* RxOp.cs: Remove unused Generic opcodes.

	* RxCompiler.cs: Emit opcodes with flags using methods which can be 
	overriden by CILCompiler.cs, so we only have to override a few methods.

	* CILCompiler.cs: Simplify based on the RxCompiler changes. Implement
	UnicodeString opcode. Throw a NotImplementedException when an unsupported
	opcode is encountered, since the IL compiler is now believed to be feature 
	complete.

2008-10-24  Zoltan Varga  <vargaz@gmail.com>

	* RxInterpreter.cs CILCompiler.cs gen-interp.cs: Fix the reading of short 
	values from the instruction stream.

	* RxOp.cs: Add some missing unicode opcodes.

	* gen-interp.cs RxInterpreter.cs: Generate Bitmap/UnicodeBitmap opcodes too.

	* CILCompiler.cs (EmitEvalMethodBody): Add an 'end_pc' argument to mark the
	end of the bytecode range which needs to be compiled. Use it to avoid
	compiling the same bytecode multiple times in various opcodes. Fix
	RxOp.Jump implementation. Add implementation for unicode opcodes.

2008-10-09  Zoltan Varga  <vargaz@gmail.com>

	* CILCompiler.cs: Implement NoBitmap/NoBitmapIgnoreCase. Fixes #432172.

2008-09-14  Zoltan Varga  <vargaz@gmail.com>

	* gen-interp.cs: New file to generate the all variants of the character 
	checking opcodes in RxInterpreter.cs.

	* RxInterpreter.cs: Replace hand written code with code generated by
	gen-interp.cs.
	
	* RxInterpreter.cs: Fix the failure case of the No<XXX> opcodes. Fixes
	#426142.

2008-09-13  Zoltan Varga  <vargaz@gmail.com>

	* RxInterpreter.cs RxCompiler.cs: Implement some missing Category opcodes.

2008-09-07  Zoltan Varga  <vargaz@gmail.com>

	* CILCompiler.cs: Override ICompiler.EmitSet too so we set op_flags for 
	Bitmap opcodes too. Fixes #424073.

2008-09-06  Zoltan Varga  <vargaz@gmail.com>

	* Regex.cs: Make the new regex interpreter+compiler the default.

2008-08-31  Zoltan Varga  <vargaz@gmail.com>

	* RxInterpreter.cs: Port the Anchor+StartOfString optimization from the old
	interpreter. Add credits.

	* RxCompiler.cs (EmitString): Lowercase the string if ignore is true.

	* CILCompiler.cs: Fix the setting of the match position in the
	anchor+char optimization.
	
	* CILCompiler.cs: Implement FastRepeatLazy.

	* CILCompiler.cs: Get rid of commented out code. Also get rid of
	frame.local_strpos_res, since the generated code already set Arg1 to
	the same value.

2008-08-30  Zoltan Varga  <vargaz@gmail.com>

	* CILCompiler.cs: Initialize all mi_ variables lazily.
	
	* CILCompiler.cs: Implement FastRepeat.

	* RxInterpreter.cs: Add back SetStartOfMatch, make it protected so as to
	avoid a warning.

	* CILCompiler.cs RxOp.cs: Merge lots of changes from RxInterpreter.cs,
	refactor the code.

2008-08-29  Zoltan Varga  <vargaz@gmail.com>

	* RxInterpreter.cs RxCompiler.cs RxOp.cs: Implement/fix this so all the
	regex tests now run. The Repeat code is taken from the old interpreter.

2008-08-28  Zoltan Varga  <vargaz@gmail.com>

	* RxInterpreter.cs RxCompiler.cs RxOp.cs: Add support for 
	Category.AnySingleline.

2008-08-27  Zoltan Varga  <vargaz@gmail.com>

	* RxCompiler.cs: Use Array.Copy since Buffer.BlockCopy operates on bytes.
	
2008-07-31  Jb Evain  <jbevain@novell.com>

	* BaseMachine.cs: clean up for NET_2_1.

2008-06-05  Roei Erez  <roeie@mainsoft.com>

	* JvmReMachine.jvm.cs: Fix a bug in match that contains
	empty group at the end.

2008-04-13  Jb Evain  <jbevain@novell.com>

	* Regex.cs: update undocumented fields for the 2.1 profile.
	Merged from the Moonlight 2 branch.

2008-02-26  Zoltan Varga  <vargaz@gmail.com>

	* CILCompiler.cs: Implement StringIgnoreCase.
	
	* CILCompiler.cs: Implement grouping support.

	* CILCompiler.cs: Implement character groups.

2008-02-25  Zoltan Varga  <vargaz@gmail.com>

	* CILCompiler.cs: Implement lots of missing opcodes.

2008-02-18  Zoltan Varga  <vargaz@gmail.com>

	* CILCompiler.cs (EmitEvalMethodBody): Check for the not-yet supported
	groups.Count > 1.

Thu Feb 14 19:03:00 CET 2008 Paolo Molaro <lupus@ximian.com>

	* RxCompiler.cs, RxInterpreter.cs, RxOp.cs, CILCompiler.cs : support for word
	boundary position opcodes, ignorecase backreference and more capture
	work.

Thu Feb 14 17:11:10 CET 2008 Paolo Molaro <lupus@ximian.com>

	* RxCompiler.cs, RxInterpreter.cs, RxOp.cs: replace EcmaDigit with
	Range, fixed matching of "" =~ /$/, implementedt TestCharGroup.
	Fixes and other misc opcodes implemented.

2008-02-13  Zoltan Varga  <vargaz@gmail.com>

	* CILCompiler.cs: Restructure some code to avoid a branch inside a loop.
	
	* CILCompiler.cs: Fix the unsafe string matching code.

	* CILCompiler.cs: Improved version which emits only one method in most cases.

	* CILCompiler.cs: Fix some comments.

	* CILCompiler.cs: New file, extracted from RxCompiler.cs.

	* RxInterpreter.cs RxCompiler.cs: First version of regex IL compiler.

Wed Feb 13 13:18:12 CET 2008 Paolo Molaro <lupus@ximian.com>

	* RxCompiler.cs, RxInterpreter.cs, RxOp.cs: unicode categories and
	some grouping/capture support.

Tue Feb 12 19:16:49 CET 2008 Paolo Molaro <lupus@ximian.com>

	* RxCompiler.cs, RxInterpreter.cs, RxOp.cs: experimental new
	interpreter.

2008-02-10  Zoltan Varga  <vargaz@gmail.com>

	* replace.cs (NeedsGroupsOrCaptures): New property. Determines whenever the
	replacement process needs access to the groups or captures properties of the
	Match object.

	* Group.cs: Add an internal ctor which avoids allocations.

	* Match.cs: Ditto.

	* BaseMachine.cs interpreter.cs: Add an optimization to avoid fully creating
	Match objects during Replace () if the replacement string is simple.

	* BaseMachine.cs Regex.cs: Make LTRReplace and RTLReplace instance methods to 
	avoid creating two machines for each Regex.Replace () call.

	* interpreter.cs (Eval): Remove a needless string allocation.

2007-12-04  Arina Itkes <arinai@mainsoft.com>

	* parser.cs: Max value of m for a construct {n,m} is 2147483647.

2007-11-15  Miguel de Icaza  <miguel@novell.com>

	* Revert the patch from Juraj Skripsky as it made the class
	non-thread safe (see #341986).

2007-11-08  Raja R Harinath  <harinath@gmail.com>

	Fix 324390
	* BaseMachine.cs (LTRReplace): Don't use non-advancement of 'ptr'
	to deduce absence of matches -- a match can have length 0.
	(RTLReplace): Likewise.

2007-11-07  Raja R Harinath  <harinath@gmail.com>

	Support RegexOptions.RightToLeft in Replace().
	* BaseMachine.cs (Replace): Use either LTRReplace or RTLReplace
	based on regex.
	(LTRReplace): Make internal and rename the MatchAppendEvaluator
	version of Replace to this.
	(RTLReplace): New.
	* Regex.cs (Replace): Use LTRReplace and RTLReplace from BaseMachine.
	* replace.cs (ReplacementEvaluator.Evaluate): Optimize simple case.
	Based on patch by Stephane Delcroix.

	* replace.cs (Compile): Don't unescape string.

2007-11-01  Gert Driesen  <drieseng@users.sourceforge.net>

	* Match.cs: Do not throw NotSupportedException on zero-length
	replacement argument.

2007-10-29 Arina Itkes <arinai@mainsoft.com>

	* Regex.cs: Moving creation of Regex machine to ctor.
	It increases an initialization time of Regex but reduce a 
	process time while APIs calling. Also it solves the problem 
	of missed multi thread synchronization.

2007-10-29 Arina Itkes <arinai@mainsoft.com>
	
	* Match.cs: Fix for Result method of Match. Throwing an exception 
	if Result method was called on a failed Match. 

2007-10-24  Juraj Skripsky <js@hotfeet.ch>

	* Regex.cs: Store and re-use IMachine, no need to re-instantiate
	it every time we're matching.
	
2007-10-24 Arina Itkes <arinai@mainsoft.com>

	* Regex.cs Match.cs arch.cs compiler.cs interpreter.cs
	 Refactoring of Interpreter with extracting of base abstract class 
	 that executes some methods that were moved from Regex and Match classes.
	 Added a field that maps group numbers to group names in Regex for 
	 improvement of performance of GroupNameFromNumber method.

2007-10-21  Gert Driesen  <drieseng@users.sourceforge.net>

	* RegexTest.cs: Removed. Test was already moved to the appropriate
	location. 

2007-06-21  Juraj Skripsky <js@hotfeet.ch>

	* quicksearch.ch: Optimization. Add byte array as skip table for
	chars <= 255, falling back to the hashtable for chars > 255 and
	skip distances > 255.

2007-04-18  Raja R Harinath  <rharinath@novell.com>

	Fix #80554
	* parser.cs (ResolveReferences): Don't throw an expression if a
	capture assertion reference cannot be resolved.
	(ParseGroupingConstruct): Provide fallback expression to a capture
	assertion.
	* syntax.cs (CaptureAssertion): If the bareword doesn't refer to
	the name of a capture group, fallback to treating it as a literal
	expression.

2007-04-04  Raja R Harinath  <rharinath@novell.com>

	* interpreter.cs (Eval) <OpCode.Reference>: Distribute for loop
	inside if.
	for () if (a) s1; else s2; => if (a) for () s1; else for () s2;

2007-04-03  Raja R Harinath  <rharinath@novell.com>

	* Regex.cs (~Regex): Don't define in NET_2_0 profile.

2007-01-02  Raja R Harinath  <rharinath@novell.com>

	Fix #79472
	* parser.cs (Parser.GetMapping): Use the actual group numbers to
	build the mapping.

2006-09-28  Andrew Skiba  <andrews@mainsoft.com>

	* Regex.cs: TARGET_JVM

2006-05-30  Gert Driesen  <drieseng@users.sourceforge.net>

	* CaptureCollection.cs: Removed virtual keyword to fix API mismatches.
	* MatchCollection.cs: Removed virtual keyword to fix API mismatches.
	* GroupCollection.cs: Removed virtual keyword to fix API mismatches.

2006-05-08  Raja R Harinath  <rharinath@novell.com>

	Fix #78278
	Remove 65535-limit on number of repetitions matched by a pattern.
	We still have a 65535 limit on the length of a pattern and the
	number of groups in a pattern.
	* compiler.cs (PatternCompiler.EmitCount): New.  Emits an int as
	two ushorts into the program stream.
	(EmitInfo, EmitRepeat, EmitFastRepeat): Use it to emit integers
	rather than shorts.
	* interpreter.cs (Intepreter.ReadProgramCount): Read an int
	emitted into the program stream.
	(Interpreter): Use it.  Update counts.
	(Interpreter.Eval) [OpCode.Repeat, OpCode.FastRepeat]: Likewise.
	* parser.cs (ParseGroup): Pass 0x7ffffff as the max value for '*'
	and '+' repetition patterns.
	* arch.cs (Info, Repeat, FastRepeat): Update description.

2006-04-18  Raja R Harinath  <rharinath@novell.com>

	Treat fixed repetitions of simple regexes as simple too.
	* syntax.cs (Expression.IsComplex): Make abstract.
	(Group.IsComplex, Alternation.IsComplex): Move ...
	(CompositeExpression.IsComplex): ... here.
	(Group.GetAnchorInfo): Reduce allocations.  Avoid creating another
	ArrayList, and use a StringBuilder to build up the string.
	(Repetition.GetAnchorInfo): Use a StringBuilder to build up the string.
	(ExpressionAssertion.IsComplex): Override.

2006-04-17  Florian Gross  <flgr@ccan.de>
	    Raja R Harinath  <rharinath@novell.com>

	* syntax.cs (CharacterClass.Compile): Emit categories after the
	character intervals so that the evaluator can pick up the
	'IgnoreCase' flag.

2006-04-07  Raja R Harinath  <rharinath@novell.com>

	Fix #78007
	* interpreter.cs (Interpreter.Eval) [Anchor, Position.StartOfString]:
	Don't reset 'ptr' to 0 during forward scan.

	Fix #76345
	* interpreter.cs (Interpreter.FastEval) [FastRepeat]: If the first
	tail operation has a 'negate' flag, avoid the "match next char"
	optimization.

	Fix #69269
	* arch.cs (OpCode.NotCategory): New.  Stands for matching a
	character _not_ from the given category.
	* debug.cs (DisassembleBlock): Handle it.
	* compiler.cs (ICompiler.EmitNotCategory): New.
	(Compiler.EmitNotCategory): New.  Emit OpCode.NotCategory.
	* syntax.cs (CharacterClass.Compile): Don't conflate negation of
	the character class and negation of the category.  Use
	EmitNotCategory.
	* interpreter.cs (Interpreter.Eval): Pass OpCode.NotCategory to
	EvalChar.
	(Interpreter.EvalChar): Handle it.

2006-04-06  Raja R Harinath  <rharinath@novell.com>

	Fix #77487
	* interpreter.cs (Eval) [Until, FastUntil]: Set 'deep' to null
	when evaluating the tail.  Ensure that backtracks don't confuse
	the recursion vs. iteration detector.

2006-04-03  Raja R Harinath  <rharinath@novell.com>

	* interpreter.cs (Eval) [Until, lazy]: Avoid extra evaluation on a
	degenerate match.

2006-03-30  Raja R Harinath  <harinath@gmail.com>

	Fix #77626
	* parser.cs (Parser.ParseCharacterClass): Don't automatically
	assume there's a range when we see '-'.  Ensure that we have seen
	at least one other character, and that we aren't already parsing a
	range.  Handle some more errors.

2005-12-19  Kornél Pál  <kornelpal@hotmail.com>

	* Regex.cs: Added support for regular expressions compiled to
	  assemblies by compiling the pattern. This solution ignores existing
	  CIL code but provides full support for regular expression classes
	  compiled by MS.NET.

2005-11-21  Sebastien Pouliot  <sebastien@ximian.com> 

	* CaptureCollection.cs: Fixed length check.
	* Group.cs: Added missing validation for Synchronized method.
	* Match.cs: Added missing validation for Synchronized and Result 
	methods.
	* MatchEvaluator.cs: Added [Serializable] for 2.0 profile.
	* RegexCompilationInfo.cs: Added missing property validation.
	* Regex.cs: Implemented UseOptionC and UseOptionR protected methods
	(now documented). Fixed API for 2.0 profile.
	* RegexRunner.cs: Stubbed CharInClass for 2.0 profile.

2005-11-17  Sebastien Pouliot  <sebastien@ximian.com> 
 
	* Match.cs: Removed the ": base ()" on the private ctor as it is
	unrequired and cause an extra public ctor to added (bug #76736).
	* MatchCollection.cs: Add missing virtual to indexer property.

2005-09-23  Raja R Harinath  <rharinath@novell.com>

	* interpreter.cs (Interpreter.Eval) [OpCode.Until]: Invert the
	sense of a test to reflect the code re-organization.

2005-09-22  Raja R Harinath  <rharinath@novell.com>

	Fix #72152, #72989.
	* interpreter.cs (Interpreter.Eval) [OpCode.Until]: Avoid some
	cases of recursion when dealing with eager quantifiers too.  We
	now avoid recursion when handling the innermost quantifier.
	(Interpreter.IntStack, Interpreter.stack): New.  Stack to help
	implement backtracking in eager quantifiers.

2005-09-21  Raja R Harinath  <rharinath@novell.com>

	* interpreter.cs (Interpreter.Eval) [OpCode.Until]: Avoid some
	cases of recursion when dealing with the minimum count and lazy
	quantifiers.

2005-08-23  Raja R Harinath  <rharinath@novell.com>

	* regex.cs: Remove.  Split into ...
	* MatchEvaluator.cs, Regex.cs, RegexCompilationInfo.cs,	
	RegexOptions.cs: ... these.  Now every publicly exposed type in
	this namespace has its own file.

2005-07-21  Florian Gross  <flgr@ccan.de>

	* Fixed a bug in category.cs that caused ECMAScript \d to fail.

2005-07-13  Raja R Harinath  <rharinath@novell.com>

	Make even more lazier.
	* MatchCollection.cs (TryToGet): Don't generate match i+1 when
	we're looking for match i.  Change post-conditions.
	(FullList): New helper property.  Ensures the list is fully populated.
	(Count, CopyTo): Use it.
	(Enumerator.Current): Update to new post-conditions of TryToGet.
	(Enumerator.MoveNext): Likewise.  Don't modify index if we're
	beyond the end.

2005-07-08  Raja R Harinath  <rharinath@novell.com>

	* MatchCollection.cs: Convert to incremental mode.
	* regex.cs (Regex.Matches): Update.  Pass responsibility of
	generating all matches to MatchCollection.

2005-06-14  Raja R Harinath  <harinath@gmail.com>

	* parser.cs (Parser.ConsumeWhitespace): Add bounds check.

	Fix #74753.
	* Match.cs (Match) [zero-argument variant]: Make private.
	* GroupCollection (Item) [string variant]: Don't look for the
	group number in an empty match.

2005-06-10  Raja R Harinath  <rharinath@novell.com>

	* interpreter.cs (Interpreter.GenerateMatch): Avoid allocating two
	intermediate arrays to build the final result.
	(Interpreter.GetGroupInfo, Interpreter.PopulateGroup): New helper
	functions.
	* CaptureCollection.cs (list): Change from ArrayList to list.
	(SetValue): New internal helper, used by Interpreter.PopulateGroup.
	(Enumerator): Remove helper class.
	(IEnumerator.GetEnumerator): Just use list.GetEnumerator.
	* GroupCollection.cs: Likewise.
	* Group.cs (Group): Move responsibility of populating 'Captures'
	to Interpreter.PopulateGroup.
	* Match.cs (Match): Move responsibility of populating 'Groups' to
	Interpreter.GenerateMatch.

2005-05-25  Raja R Harinath  <rharinath@novell.com>

	* replace.cs (ReplacementEvaluator.Compile): Rewrite to avoid
	creating several intermediate strings.  Simplify internal
	intermediate representation.
	(ReplacementEvaluator.EvaluateAppend): New.  Version of Evaluate
	that builds the result directly on a passed-in StringBuilder.
	(ReplacementEvaluator.Evaluate): Just a wrapper around
	EvaluateAppend.
	* regex.cs (MatchAppendEvaluator): New internal delegate.
	(Regex.Replace): Use MatchAppendEvaluator.
	(Regex.Adapter): New class used to adapt a MatchEvaluator to a
	MatchAppendEvaluator.

2005-05-24  Raja R Harinath  <rharinath@novell.com>

	* replace.cs (ReplacementEvaluator.CompileTerm): Fix group
	returned by $+.

2005-05-20  Ben Maurer  <bmaurer@ximian.com>

	* regex.cs: Some memory allocation optimizations.

2005-05-20  Raja R Harinath  <rharinath@novell.com>

	Fix #74735.
	* replace.cs (ReplacementEvaluator.Compile): Allow CompileTerm to
	fail and yet have advanced the pointer.  Append the scanned-over
	portion to the "literal" being built.
	(ReplacementEvaluator.CompileTerm): Don't throw any exceptions.
	If a term cannot be recognized, just return null.

	* compiler.cs (InterpreterFactory.GroupCount): Fix.  The 0'th
	index corresponds to Opcode.Info.

	* parser.cs (Parser.Unescape): If the string doesn't contain any
	'\' character, don't allocate a new string.

	* replace.cs (ReplacementEvalutator.Term.AppendResult): Rename
	from GetResult.  Append to a passed-in StringBuilder rather than
	return a string.
	(ReplacementEvaluator.Evaluate): Update.
	
	* Capture.cs, Group.cs, Match.cs: New files split out of ...
	* match.cs: ... this.  Remove.

2005-02-27 Gonzalo Paniagua Javier <gonzalo@ximian.com>

	* parser.cs: stuff inside {} might not be a quantifier. Fixes
	bug #69193.

2005-01-10 Gonzalo Paniagua Javier <gonzalo@ximian.com>

	* quicksearch.cs: handle IgnoreCase when getting the shift distance.
	Fixes bug #69065. Patch by mei@work.email.ne.jp.

2005-01-08  Miguel de Icaza  <miguel@ximian.com>

	* syntax.cs: Applied patch from mei@work.email.ne.jp to fix bug
	#71077.

	* parser.cs: Turns out that \digit sequences are octal sequences
	(no leading zero is needed);  And the three octal digit rule
	applies to the leading zero as well.

	This fixes the Unescape method.

2004-11-29 Gonzalo Paniagua Javier <gonzalo@ximian.com>

	* regex.cs: use NextMatch to move on to the next match. Fixes bug
	#57274.

2004-11-09  Atsushi Enomoto  <atsushi@ximian.com>

	* parser.cs : cast.

2004-11-08  Ben Maurer  <bmaurer@ximian.com>

	* replace.cs, parser.cs: Use stringbuilder for allocation sanity.

2004-10-21  Joerg Rosenkranz  <joergr@voelcker.com>

	* regex.cs: Fixed a bug introduced with the last patch which
	prevented any replacements when a postive count is given.
	This also happens in all overloads without count parameter.

2004-10-18 Gonzalo Paniagua Javier <gonzalo@ximian.com>

	* regex.cs: in Replace, when count is negative, replacement continues
	to the end of the string.

	Fixes bug #68398. Patch by Jon Larimer.

2004-06-10  Gert Driesen <drieseng@users.sourceforge.net>

	* RegexRunner.cs: fixed case mismatch of methods

2004-06-10  Gert Driesen <drieseng@users.sourceforge.net>

	* RegexRunner.cs: marked TODO, added missing protected internal
	fields, throw NotImplementedException in all methods

2004-06-10  Gert Driesen <drieseng@users.sourceforge.net>

	* RegexRunnerFactory.cs: removed comment, no longer throw exception
	from ctor
	* regex.cs: fixed public API signature by renaming protected 
	internal fields and adding destructor, added MonoTODO attribute to
	fields and method that are not yet implemented, changed not 
	implemented methods to throw NotImplementedException instead of
	Exception, fixed names of field that are serialized

2004-06-06  Jambunathan K <kjambunathan@novell.com>
	
	* parser.cs: Fixed issues with Regex.Unescape() identified as part of
	debugging bug #58256. The original problem reported was about
	inconsistency between the way we treat replacement patterns and the 
	way microsoft treats the replacement patterns in Regex.Replace(). MS
	implementation is buggy and doesn't honour escape sequences in the
	replacement patterns, even though the SDK claims otherwise.

	
2004-06-01  Gonzalo Paniagua Javier <gonzalo@ximian.com>

	* syntax.cs: re-applied my patch from 2004-05-27 plus a fix which is
	emitting a Category.All if both a category and its negated value are
	present.

2004-06-01  Gonzalo Paniagua Javier <gonzalo@ximian.com>

	* syntax.cs: reverting my previous patch. It causes bigger problems.

2004-05-27  Gonzalo Paniagua Javier <gonzalo@ximian.com>

	* category.cs: added LastValue field to mark the end of enum Category.
	* syntax.cs: in CharacterClass, use Category.LastValue to get the size
	of the array needed. Use a BitArray instead of bool[].
	In AddCategory(), don't set the opposite category as false. Fixes
	bug #59150. All tests pass.

2004-05-25  Jackson Harper  <jackson@ximian.com>

	* parser.cs: Allow creating a regular expression using {,n} as the
	specified. The min bounds is set to -1, I am not completely sure
	if that is what it is supposed to be but MS does not set it to 0
	based on testing. Patch by dave-gnome-bugs@earth.li. Fixes bug #56761.

2004-05-12  Dick Porter  <dick@ximian.com>

	* regex.cs: 
	* quicksearch.cs: 
	* RegexRunnerFactory.cs: 
	* RegexRunner.cs: More public API difference fixes.

	* GroupCollection.cs: 
	* MatchCollection.cs: 
	* CaptureCollection.cs: Moved GroupCollection, MatchCollection and
	CaptureCollection so that they no longer inherit from the
	non-standard RegexCollectionBase class.  Fixes the API difference.

2004-04-19  Gonzalo Paniagua Javier <gonzalo@ximian.com>

	* arch.cs:
	* compiler.cs:
	* interpreter.cs:
	* parser.cs:
	* syntax.cs:
	Patch by Eric Durand Tremblay.
	1) Capture inner group when named.
	2) Resolved parse error caused by not capturing inner group
	3) Resolved incorrect capture group
	4) Now, not capturing anything when unnamed ( correct behavior)


2004-04-19  Gonzalo Paniagua Javier <gonzalo@ximian.com>

	* arch.cs:
	* compiler.cs:
	* interpreter.cs:
	* parser.cs:
	* syntax.cs: converted to unix line endings.

2004-03-30  Lluis Sanchez Gual <lluis@ximian.com>

	* collections.cs: In the indexer, return an empty group if the requested
	group is not found.
	* match.cs: Added default constructor for Group.
	
2004-03-24  Gonzalo Paniagua Javier <gonzalo@ximian.com>

	* parser.cs: fixed group numbering.

2004-03-22  Jackson Harper  <jackson@ximian.com>

	* parser.cs: Use the group number as the name in mapping. Patch by
	Gert Driesen.
	* regex.cs: Fix off by one error. Patch by Gert Driesen.

2004-03-17  Francois Beauchemin <beauche@softhome.net>
 	* syntax.cs, interpreter.cs, quicksearch.cs, regex.cs, compiler.cs : 
 		Revised support for RigthToLeft. 
 		quicksearch has now an reverse option.		
 		This fixes bug #54537 
 
  	* regex.cs, compiler.cs :
 	 	Some code to support CILCompiler.		
 	* regex.cs : 
 		Added some undocumented of MS.
 
2004-03-16  Gonzalo Paniagua Javier <gonzalo@ximian.com>

	* parser.cs: allow a @"\0" escape sequence. Fixes bug #54797.

2004-02-01  Miguel de Icaza  <miguel@ximian.com>

	* syntax.cs, interval.cs: Applied patch from Marco Cravairo
	through Francois Beauchemin who reviewed on the mailing list.
	This fixes bug #45976

2004-01-16  Gonzalo Paniagua Javier <gonzalo@ximian.com>

	* parser.cs: an opening brace without a
	quantifier do not cause a parse error. Fixes bug #52924.

2004-01-07  Lluis Sanchez Gual <lluis@ximian.com>

	* regex.cs: In Split(), if the last match is at the end of the string, 
	an empty string must be added to the array of results.

2003-12-15  Sanjay Gupta <gsanjay@novell.com>
	* match.cs: Check for null value before Substring method call.  
	Fixes bug #52034.

2003-11-21  Juraj Skripsky <js@hotfeet.ch>

	* quicksearch.cs: Create and use hashtable only for "long" search 
	strings. 

	(Search): Use simple scan for a single-character search strings.
	
	(GetChar): Simplify case sensitivity handling.

2003-11-27  Gonzalo Paniagua Javier <gonzalo@ximian.com>

	* interpreter.cs: when evaluating a degenerate match, restore the
	RepeatContext if fail. Fixes bug #42529.

2003-11-22  Jackson Harper <jackson@ximian.com>

	* regex.cs: Add CultureInvariant flag to RegexOptions.
	
2003-11-20  Juraj Skripsky <js@hotfeet.ch>

	* quicksearch.cs: Use a hashtable instead of an array for the
	shift table to improve the memory usage.  

2003-11-19  Gonzalo Paniagua Javier <gonzalo@ximian.com>

	* regex.cs:
	(Split): include capture groups in the results, if any. Fixes bug
	#51146.

2003-07-09  Gonzalo Paniagua Javier <gonzalo@ximian.com>

	* regex.cs: patch from Eric Lindvall <eric@5stops.com> that fixes bug
	#44830.

2003-03-05  Miguel de Icaza  <miguel@ximian.com>

	* category.cs (CategoryUtils.CategoryFromName): Use StartsWith
	("Is") instead of a substring for (0,2) which was throwing an
	exception causing Category.None to be returned

2003-01-17  Gonzalo Paniagua Javier <gonzalo@ximian.com>

	* collections.cs: fixed bug #30091.

2002-12-20  Gonzalo Paniagua Javier <gonzalo@ximian.com>

	* regex.cs: fixed little mistake (closes #35860).

2002-11-12 Jackson Harper <jackson@latitudegeo.com>

	* arch.cs compiler.cs regex.cs: Added mapping attribute to MachineFactories

2002-11-06  Gonzalo Paniagua Javier <gonzalo@ximian.com>

	* parser.cs: detect illegal \ at end of pattern. Fixes 31334.

2002-10-25  Gonzalo Paniagua Javier <gonzalo@ximian.com>

	* parser.cs: applied fix from Tim Haynes (thaynes@openlinksw.com) to
	solve bug #32807. Also modified GetMapping to return the same as MS.

2002-08-28  Juli Mallett  <jmallett@FreeBSD.org>

	* arch.cs, compiler.cs: Give the interpreter machine a property
	for the retrieval of the group count.

	* regex.cs: Use the new GroupCount property of the factory to
	initialise the current group count, and restructure code to compile
	the pattern only the first time it is needed (essentially backing
	out the previous revision of regex.cs, to use the new code.)

2002-08-14  Cesar Octavio Lopez Nataren <cesar@ciencias.unam.mx>

	* regex.cs: Added the ctr for ISerializable implementation and
	implemented the GetObjectData function.

2002-07-30  Juli Mallett  <jmallett@FreeBSD.org>

	* regex.cs: Fixed bug where the expression would not be
	re-evaluated for grouping purposes when factory caches were
	used, resulting in no groups being recognised after one call
	with a given pattern and no change in options.

2002-05-13  Dan Lewis  <dihlewis@yahoo.co.uk>

	* regex.cs: Fixed bug in split.

2002-05-08  Dan Lewis  <dihlewis@yahoo.co.uk>

	* interpreter.cs: Moved to an array-based stack representation
	for faster captures.

	* match.cs, collections.cs: Decoupled capture representation from
	interpreter internals.

	* cache.cs: Changed Key type from struct to class for speed.

2002-04-06  Dan Lewis  <dihlewis@yahoo.co.uk>

	* cache.cs: Object methods should be overridden with "override".

2002-04-04  Dan Lewis  <dihlewis@yahoo.co.uk>

	* RegexRunner.cs, RegexRunnerFactory.cs: MS support classes. Stubs
	added for completeness.

	* regex.cs, match.cs, collections.cs: Serializable attribute.

2002-04-04  Dan Lewis  <dihlewis@yahoo.co.uk>

	* regex.cs: Added static Matches and IsMatch methods.

2002-04-03  Dan Lewis  <dihlewis@yahoo.co.uk>

	* ChangeLog: Added changelog.

	* cache.cs: Fixed bug in MRUList.Evict.
