Remove character class subtraction

Fixes #7

Author: roberthusak

src/Peachpie.Library.RegularExpressions/RegexCharClass.cs

@@ -403,7 +403,6 @@ these intervals. It follows from the nature of the L on each interval.
         private readonly StringBuilder _categories;
         private bool _canonical;
         private bool _negate;
-        private RegexCharClass _subtractor;
 
 #if DEBUG
         static RegexCharClass()
@@ -433,20 +432,19 @@ public RegexCharClass()
             _categories = new StringBuilder();
         }
 
-        private RegexCharClass(bool negate, List<SingleRange> ranges, StringBuilder categories, RegexCharClass subtraction)
+        private RegexCharClass(bool negate, List<SingleRange> ranges, StringBuilder categories)
         {
             _rangelist = ranges;
             _categories = categories;
             _canonical = true;
             _negate = negate;
-            _subtractor = subtraction;
         }
 
         public bool CanMerge
         {
             get
             {
-                return !_negate && _subtractor == null;
+                return !_negate;
             }
         }
 
@@ -507,12 +505,6 @@ private void AddSet(string set)
             }
         }
 
-        public void AddSubtraction(RegexCharClass sub)
-        {
-            Debug.Assert(_subtractor == null, "Can't add two subtractions to a char class. ");
-            _subtractor = sub;
-        }
-
         /// <summary>
         /// Adds a single range of characters to the class.
         /// </summary>
@@ -715,20 +707,23 @@ public static char SingletonChar(string set)
 
         public static bool IsMergeable(string charClass)
         {
-            return (!IsNegated(charClass) && !IsSubtraction(charClass));
+            Debug.Assert(!IsSubtraction(charClass));
+            return !IsNegated(charClass);
         }
 
         public static bool IsEmpty(string charClass)
         {
-            return (charClass[CATEGORYLENGTH] == 0 && charClass[FLAGS] == 0 && charClass[SETLENGTH] == 0 && !IsSubtraction(charClass));
+            Debug.Assert(!IsSubtraction(charClass));
+            return (charClass[CATEGORYLENGTH] == 0 && charClass[FLAGS] == 0 && charClass[SETLENGTH] == 0);
         }
 
         /// <summary>
         /// <c>true</c> if the set contains a single character only
         /// </summary>
         public static bool IsSingleton(string set)
         {
-            if (set[FLAGS] == 0 && set[CATEGORYLENGTH] == 0 && set[SETLENGTH] == 2 && !IsSubtraction(set) &&
+            Debug.Assert(!IsSubtraction(set));
+            if (set[FLAGS] == 0 && set[CATEGORYLENGTH] == 0 && set[SETLENGTH] == 2 &&
                 (set[SETSTART] == LastChar || set[SETSTART] + 1 == set[SETSTART + 1]))
                 return true;
             else
@@ -737,13 +732,17 @@ public static bool IsSingleton(string set)
 
         public static bool IsSingletonInverse(string set)
         {
-            if (set[FLAGS] == 1 && set[CATEGORYLENGTH] == 0 && set[SETLENGTH] == 2 && !IsSubtraction(set) &&
+            Debug.Assert(!IsSubtraction(set));
+            if (set[FLAGS] == 1 && set[CATEGORYLENGTH] == 0 && set[SETLENGTH] == 2 &&
                 (set[SETSTART] == LastChar || set[SETSTART] + 1 == set[SETSTART + 1]))
                 return true;
             else
                 return false;
         }
 
+        /// <remarks>
+        /// Character class subtraction is not supported, used just in assertions in a regressive test fashion.
+        /// </remarks>
         private static bool IsSubtraction(string charClass)
         {
             return (charClass.Length > SETSTART + charClass[SETLENGTH] + charClass[CATEGORYLENGTH]);
@@ -775,42 +774,32 @@ public static bool IsWordChar(char ch)
 
         public static bool CharInClass(char ch, string set)
         {
-            return CharInClassRecursive(ch, set, 0);
-        }
-
-        private static bool CharInClassRecursive(char ch, string set, int start)
-        {
-            int mySetLength = set[start + SETLENGTH];
-            int myCategoryLength = set[start + CATEGORYLENGTH];
-            int myEndPosition = start + SETSTART + mySetLength + myCategoryLength;
-
-            bool subtracted = false;
+            int mySetLength = set[SETLENGTH];
+            int myCategoryLength = set[CATEGORYLENGTH];
+            int myEndPosition = SETSTART + mySetLength + myCategoryLength;
 
-            if (set.Length > myEndPosition)
-            {
-                subtracted = CharInClassRecursive(ch, set, myEndPosition);
-            }
+            Debug.Assert(set.Length == myEndPosition);
 
-            bool b = CharInClassInternal(ch, set, start, mySetLength, myCategoryLength);
+            bool b = CharInClassInternal(ch, set, mySetLength, myCategoryLength);
 
             // Note that we apply the negation *before* performing the subtraction.  This is because
             // the negation only applies to the first char class, not the entire subtraction.
-            if (set[start + FLAGS] == 1)
+            if (set[FLAGS] == 1)
                 b = !b;
 
-            return b && !subtracted;
+            return b;
         }
 
         /// <summary>
         /// Determines a character's membership in a character class (via the
         /// string representation of the class).
         /// </summary>
-        private static bool CharInClassInternal(char ch, string set, int start, int mySetLength, int myCategoryLength)
+        private static bool CharInClassInternal(char ch, string set, int mySetLength, int myCategoryLength)
         {
             int min;
             int max;
             int mid;
-            min = start + SETSTART;
+            min = SETSTART;
             max = min + mySetLength;
 
             while (min != max)
@@ -829,22 +818,22 @@ private static bool CharInClassInternal(char ch, string set, int start, int mySe
             // SETSTART is odd, we can simplify it out of the equation.  But if it changes we need to
             // reverse this check.
             Debug.Assert((SETSTART & 0x1) == 1, "If SETSTART is not odd, the calculation below this will be reversed");
-            if ((min & 0x1) == (start & 0x1))
+            if ((min & 0x1) == 0)       // Note: originally ((min & 0x1) == (start & 0x1)), but start is always 0
                 return true;
             else
             {
                 if (myCategoryLength == 0)
                     return false;
 
-                return CharInCategory(ch, set, start, mySetLength, myCategoryLength);
+                return CharInCategory(ch, set, mySetLength, myCategoryLength);
             }
         }
 
-        private static bool CharInCategory(char ch, string set, int start, int mySetLength, int myCategoryLength)
+        private static bool CharInCategory(char ch, string set, int mySetLength, int myCategoryLength)
         {
             UnicodeCategory chcategory = CharUnicodeInfo.GetUnicodeCategory(ch);
 
-            int i = start + SETSTART + mySetLength;
+            int i = SETSTART + mySetLength;
             int end = i + myCategoryLength;
             while (i < end)
             {
@@ -993,11 +982,9 @@ private static RegexCharClass ParseRecursive(string charClass, int start)
                 ranges.Add(new SingleRange(first, last));
             }
 
-            RegexCharClass sub = null;
-            if (charClass.Length > myEndPosition)
-                sub = ParseRecursive(charClass, myEndPosition);
+            Debug.Assert(charClass.Length == myEndPosition);
 
-            return new RegexCharClass(charClass[start + FLAGS] == 1, ranges, new StringBuilder(charClass.Substring(end, myCategoryLength)), sub);
+            return new RegexCharClass(charClass[start + FLAGS] == 1, ranges, new StringBuilder(charClass.Substring(end, myCategoryLength)));
         }
 
         /// <summary>
@@ -1046,9 +1033,6 @@ public string ToStringClass()
 
             vsb.Append(_categories.ToString());
 
-            if (_subtractor != null)
-                vsb.Append(_subtractor.ToStringClass());
-
             return vsb.ToString();
         }
 

src/Peachpie.Library.RegularExpressions/RegexParser.cs

@@ -925,41 +925,10 @@ private RegexCharClass ScanCharClass(bool caseInsensitive, bool scanOnly)
                     inRange = false;
                     if (!scanOnly)
                     {
-                        bool processed = false;
-                        if (ch == '[' && !fTranslatedChar && !firstChar)
-                        {
-                            // We thought we were in a range, but we're actually starting a subtraction.
-                            // In that case, we'll add chPrev to our char class, skip the opening [, and
-                            // scan the new character class recursively. If the subtraction class is
-                            // invalid, we assume that it was not intended, as PCRE has no subtractions.
-
-                            // Back up the current text position
-                            int subStartPos = Textpos();
-
-                            // Scan the supposed subtraction
-                            var subtracted = ScanCharClass(caseInsensitive, scanOnly);
-
-                            if (CharsRight() > 0 && RightChar() != ']')
-                            {
-                                // If the subtraction is invalid, rollback to the previous text position
-                                // and treat '[' as any other character
-                                Textto(subStartPos);
-                            }
-                            else
-                            {
-                                cc.AddChar(chPrev);
-                                cc.AddSubtraction(subtracted);
-                                processed = true;
-                            }
-                        }
-
-                        if (!processed)
-                        {
-                            // a regular range, like a-z
-                            if (chPrev > ch)
-                                throw MakeException(SR.ReversedCharRange);
-                            cc.AddRange(chPrev, ch);
-                        }
+                        // a regular range, like a-z
+                        if (chPrev > ch)
+                            throw MakeException(SR.ReversedCharRange);
+                        cc.AddRange(chPrev, ch);
                     }
                 }
                 else if (CharsRight() >= 2 && RightChar() == '-' && RightChar(1) != ']')
@@ -969,24 +938,6 @@ private RegexCharClass ScanCharClass(bool caseInsensitive, bool scanOnly)
                     inRange = true;
                     MoveRight();
                 }
-                else if (CharsRight() >= 1 && ch == '-' && !fTranslatedChar && RightChar() == '[' && !firstChar)
-                {
-                    // we aren't in a range, and now there is a subtraction.  Usually this happens
-                    // only when a subtraction follows a range, like [a-z-[b]]
-                    if (!scanOnly)
-                    {
-                        MoveRight(1);
-                        cc.AddSubtraction(ScanCharClass(caseInsensitive, scanOnly));
-
-                        if (CharsRight() > 0 && RightChar() != ']')
-                            throw MakeException(SR.SubtractionMustBeLast);
-                    }
-                    else
-                    {
-                        MoveRight(1);
-                        ScanCharClass(caseInsensitive, scanOnly);
-                    }
-                }
                 else
                 {
                     if (!scanOnly)

tests/Peachpie.Library.RegularExpressions.Tests/PcreTests.cs

@@ -498,5 +498,15 @@ public void TestSeemingCharacterClassSubtraction()
             Assert.False(match(pattern, @"\").Success);
             Assert.False(match(pattern, "\"").Success);
         }
+
+        [Fact]
+        public void TestNotSupportedCharacterClassSubtraction()
+        {
+            Assert.False(match(@"/[a-z-[aeiuo]]/", "b").Success);
+            Assert.False(match(@"/[a-z#-[aeiuo]]/", "b").Success);
+            Assert.True(match(@"/[a-z-[aeiuo]]/", "-]").Success);
+            Assert.True(match(@"/[a-z#-[aeiuo]]/", "-]").Success);
+            Assert.True(match(@"/[a-z#-[aeiuo]]/", "#]").Success);
+        }
     }
 }