2006-09-11 Gonzalo Paniagua Javier <gonzalo@ximian.com>

[mono.git] / mcs / class / System / System.Text.RegularExpressions / interpreter.cs

diff --git a/mcs/class/System/System.Text.RegularExpressions/interpreter.cs b/mcs/class/System/System.Text.RegularExpressions/interpreter.cs
index 84a889ff81aae5c0d2fbfc06db8d36ac9094d3a2..cc0de2c747dc4fc7f5ed7ab8ff85286b0cab0eb3 100644 (file)
--- a/mcs/class/System/System.Text.RegularExpressions/interpreter.cs
+++ b/mcs/class/System/System.Text.RegularExpressions/interpreter.cs
@@ -35,6 +35,14 @@ using System.Globalization;
 namespace System.Text.RegularExpressions {
 
        class Interpreter : IMachine {
+               private int ReadProgramCount (int ptr)
+               {
+                       int ret = program [ptr + 1];
+                       ret <<= 16;
+                       ret += program [ptr];
+                       return ret;
+               }
+
                public Interpreter (ushort[] program) {
                        this.program = program;
                        this.qs = null;
@@ -43,13 +51,13 @@ namespace System.Text.RegularExpressions {
 
                        Debug.Assert ((OpCode)program[0] == OpCode.Info, "Regex", "Cant' find info block");
 
-                       this.group_count = program[1] + 1;
-                       this.match_min = program[2];
-                       //this.match_max = program[3];
+                       this.group_count = ReadProgramCount (1) + 1;
+                       this.match_min = ReadProgramCount (3);
+                       //this.match_max = ReadProgramCount (5);
 
                        // setup
 
-                       this.program_start = 4;
+                       this.program_start = 7;
                        this.groups = new int [group_count];
                }
 
@@ -106,16 +114,16 @@ namespace System.Text.RegularExpressions {
                                                //      True
 
                                                switch ((Position)program[pc + 4]) {
-                                               case Position.StartOfString:                                                    
+                                               case Position.StartOfString:
                                                        if (anch_reverse || anch_offset == 0) {
-                                                               ptr = anch_offset;
+                                                               if (anch_reverse)
+                                                                       ptr = anch_offset;
                                                                if (TryMatch (ref ptr, pc + skip))
                                                                        goto Pass;
                                                        }
                                                        break;
                                                
                                                case Position.StartOfLine:
-                                                                                                       
                                                         if (anch_ptr == 0) {
                                                                ptr = 0;
                                                                if (TryMatch (ref ptr, pc + skip))
@@ -420,10 +428,10 @@ namespace System.Text.RegularExpressions {
                                case OpCode.Repeat: {
                                        this.repeat = new RepeatContext (
                                                this.repeat,                    // previous context
-                                               program[pc + 2],                // minimum
-                                               program[pc + 3],                // maximum
+                                               ReadProgramCount (pc + 2),              // minimum
+                                               ReadProgramCount (pc + 4),              // maximum
                                                (flags & OpFlags.Lazy) != 0,    // lazy
-                                               pc + 4                          // subexpression
+                                               pc + 6                          // subexpression
                                        );
 
                                        if (Eval (Mode.Match, ref ptr, pc + program[pc + 1]))
@@ -561,10 +569,10 @@ namespace System.Text.RegularExpressions {
                                case OpCode.FastRepeat: {
                                        this.fast = new RepeatContext (
                                                fast,
-                                               program[pc + 2],                // minimum
-                                               program[pc + 3],                // maximum
+                                               ReadProgramCount (pc + 2),              // minimum
+                                               ReadProgramCount (pc + 4),              // maximum
                                                (flags & OpFlags.Lazy) != 0,    // lazy
-                                               pc + 4                          // subexpression
+                                               pc + 6                          // subexpression
                                        );
 
                                        fast.Start = ptr;
@@ -574,13 +582,17 @@ namespace System.Text.RegularExpressions {
                                        pc += program[pc + 1];          // tail expression
                                        ushort tail_word = program[pc];
 
-                                       int c1, c2;                     // first character of tail operator
-                                       int coff;                       // 0 or -1 depending on direction
+                                       int c1 = -1;            // first character of tail operator
+                                       int c2 = -1;            // ... and the same character, in upper case if ignoring case
+                                       int coff = 0;           // 0 or -1 depending on direction
 
                                        OpCode tail_op = (OpCode)(tail_word & 0xff);
                                        if (tail_op == OpCode.Character || tail_op == OpCode.String) {
                                                OpFlags tail_flags = (OpFlags)(tail_word & 0xff00);
 
+                                               if ((tail_flags & OpFlags.Negate) != 0)
+                                                       goto skip;
+
                                                if (tail_op == OpCode.String)
                                                {
                                                        int offset = 0;
@@ -605,11 +617,8 @@ namespace System.Text.RegularExpressions {
                                                else
                                                        coff = 0;
                                        }
-                                       else {
-                                               c1 = c2 = -1;
-                                               coff = 0;
-                                       }
 
+                               skip:
                                        if (fast.IsLazy) {
                                                if (!fast.IsMinimum && !Eval (Mode.Count, ref ptr, fast.Expression)) {
                                                        //Console.WriteLine ("lazy fast: failed mininum.");